home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / C Internet Config / Examples ƒ / Example / IC Resource ƒ / Syslog Component ƒ / syslog.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-15  |  9.7 KB  |  458 lines  |  [TEXT/SPM ]
  1. /*
  2.     syslog.c
  3.     
  4.     syslog glue for indirect access to the syslog component.
  5.     
  6. */
  7.  
  8.  
  9. #include <stdarg.h>
  10. #include <string.h>
  11. #include <stdio.h>
  12.  
  13. #include <Components.h>
  14.  
  15. #include "syslog.h"
  16.  
  17. #include "libsprintf.h"
  18.  
  19. ComponentInstance _gSyslogComponent=(ComponentInstance)0;
  20. char* _gSyslogBuf=(char*)0;
  21. void SyslogInit(void);
  22.  
  23. void syslog(short priority,const char* format,...){
  24.     
  25.     // try to open if not already done so
  26.     if (_gSyslogComponent==(ComponentInstance)0)
  27.         SyslogInit();
  28.     
  29.     // still couldn't open, return
  30.     if (_gSyslogComponent==(ComponentInstance)0)
  31.         return;
  32.     
  33.     // expand into buf
  34.     libvsprintf(_gSyslogBuf,format,__va(format));
  35.     
  36.     // expanded, now send to syslog
  37.     Comp_syslog(_gSyslogComponent,priority,_gSyslogBuf);
  38. }
  39.  
  40. void openlog(const char* ident,short logopts,short facility){
  41.     
  42.     // try to open if not already done so
  43.     if (_gSyslogComponent==(ComponentInstance)0)
  44.         SyslogInit();
  45.     
  46.     // still couldn't open, return
  47.     if (_gSyslogComponent==(ComponentInstance)0)
  48.         return;
  49.     
  50.     Comp_openlog(_gSyslogComponent,ident,logopts,facility);
  51. }
  52.  
  53. void closelog(void){
  54.     
  55.     // try to open if not already done so
  56.     if (_gSyslogComponent==(ComponentInstance)0)
  57.         SyslogInit();
  58.     
  59.     // still couldn't open, return
  60.     if (_gSyslogComponent==(ComponentInstance)0)
  61.         return;
  62.     
  63.     Comp_closelog(_gSyslogComponent);
  64. }
  65.  
  66. OSErr syslogerr(void){
  67.     OSErr err;
  68.     
  69.     // try to open if not already done so
  70.     if (_gSyslogComponent==(ComponentInstance)0)
  71.         SyslogInit();
  72.     
  73.     // still couldn't open, return
  74.     if (_gSyslogComponent==(ComponentInstance)0)
  75.         return (OSErr)-1;
  76.     
  77.     Comp_geterror(_gSyslogComponent,&err);
  78.     
  79.     return err;
  80. }
  81.  
  82. OSErr setsyslogfile(FSSpecPtr spec){
  83.     
  84.     // try to open if not already done so
  85.     if (_gSyslogComponent==(ComponentInstance)0)
  86.         SyslogInit();
  87.     
  88.     // still couldn't open, return
  89.     if (_gSyslogComponent==(ComponentInstance)0)
  90.         return;
  91.     
  92.     return (OSErr)Comp_setfile(_gSyslogComponent,spec);
  93. }
  94.  
  95. short setlogmask(short maskpri){
  96.     short oldpri;
  97.     
  98.     // try to open if not already done so
  99.     if (_gSyslogComponent==(ComponentInstance)0)
  100.         SyslogInit();
  101.     
  102.     // still couldn't open, return
  103.     if (_gSyslogComponent==(ComponentInstance)0)
  104.         return 0;
  105.     
  106.     oldpri=Comp_setlogmask(_gSyslogComponent,maskpri);
  107.     
  108.     return oldpri;
  109. }
  110.  
  111. /*
  112.     HaveComponentMgr
  113.     
  114.     Uses Gestalt to check for the availability of the Component Manager.  We assume that if Gestalt
  115.     does not return an error then the Component Manager exists.  If we were concerned with what
  116.     version of the Component Manager that we had we could check the result to see if it is at least
  117.     the version that we need.
  118. */
  119. Boolean HaveComponentMgr(void){
  120.     OSErr err;
  121.     long result;
  122.     
  123.     err=Gestalt(gestaltComponentMgr,&result);
  124.     
  125.     if (err!=noErr)
  126.         return false;
  127.     else
  128.         return true;
  129. }
  130.  
  131. enum {
  132.     uppExitToShellProcInfo=kPascalStackBased
  133. };
  134. #if USESROUTINEDESCRIPTORS
  135. typedef UniversalProcPtr ExitToShellUPP;
  136. #define NewExitToShellProc(routine) \
  137.     (ExitToShellUPP) NewRoutineDescriptor((ProcPtr)(routine), \
  138.         uppExitToShellProcInfo, GetCurrentISA())
  139. #define CallExitToShellProc(routine) \
  140.     CallUniversalProc((UniversalProcPtr)(routine), uppExitToShellProcInfo)
  141.  
  142. #else
  143. typedef pascal void (*ExitToShellUPP)(void);
  144.  
  145. #define NewExitToShellProc(routine) (ExitToShellUPP)(routine)
  146. #define CallExitToShellProc(routine) (*(routine))()
  147.  
  148. #endif
  149.  
  150. #define DisposeExitToShellProc(routine) DisposeRoutineDescriptor((UniversalProcPtr)routine)
  151.  
  152. static ExitToShellUPP _gSyslog_oldETS;
  153. static ExitToShellUPP _gSyslog_newETS;
  154. static long _gSyslog_A5;
  155.  
  156. pascal void SyslogAtExit(void);
  157. pascal void SyslogAtExit(void){
  158.     
  159. #if defined(powerc)||defined(__powerc)
  160. #else
  161.     // 68k code
  162.     SetA5(_gSyslog_A5);
  163. #endif
  164.     
  165.     // if we get here then the component has been opened and it needs closed
  166.     DisposePtr((Ptr)_gSyslogBuf);
  167.     CloseComponent(_gSyslogComponent);
  168.     
  169.     DisposeRoutineDescriptor(_gSyslog_newETS);
  170.     
  171.     CallExitToShellProc(_gSyslog_oldETS);
  172.     return;
  173. }
  174.  
  175. /*
  176.     SyslogInit
  177.     
  178.     Initialize the internal syslog glue.  Also inserts a ETS patch to ensure that the
  179.     component gets closed when the app is quitting.
  180. */
  181. void SyslogInit(void){
  182.     Component theComp;
  183.     ComponentDescription desc;
  184.     
  185.     if (!HaveComponentMgr())
  186.         return;
  187.     
  188.     if (_gSyslogComponent!=(ComponentInstance)0)
  189.         return; // already initialized
  190.     
  191.     _gSyslogBuf=(char*)NewPtr(4096*2); // allocate an 8k buffer
  192.     
  193.     if (_gSyslogBuf==(char*)0)
  194.         return;
  195.     
  196.     
  197.     desc.componentType=ksyslogComponentType;
  198.     desc.componentSubType=kAnyComponentType;
  199.     desc.componentManufacturer=kAnyComponentType;
  200.     desc.componentFlags=kAnyComponentType;
  201.     desc.componentFlagsMask=kAnyComponentType;
  202.     
  203.     theComp=FindNextComponent((Component)0,&desc);
  204.     
  205.     if (theComp!=(Component)0){
  206.         
  207.         _gSyslogComponent=OpenComponent(theComp);
  208.         
  209.         if (_gSyslogComponent==(ComponentInstance)0){
  210.             DisposePtr((Ptr)_gSyslogBuf);
  211.             return;
  212.         }
  213.         
  214.         _gSyslog_newETS=NewExitToShellProc(SyslogAtExit);
  215.         
  216. #if defined(powerc)||defined(__powerc)
  217.         // nothing special here
  218. #else
  219.         // 68k code
  220.         _gSyslog_A5=SetCurrentA5();
  221. #endif
  222.         
  223.         // have the component, and it is open.  Install the ETS patch
  224.         _gSyslog_oldETS=(ExitToShellUPP)NGetTrapAddress(_ExitToShell,ToolTrap);
  225.         NSetTrapAddress((UniversalProcPtr)_gSyslog_newETS,_ExitToShell,ToolTrap);
  226.         
  227.     } else {
  228.         // couldn't find the component
  229.         DisposePtr((Ptr)_gSyslogBuf);
  230.     }
  231.     
  232.     return;
  233. }
  234.  
  235.  
  236. #if defined(powerc) || defined(__powerc)
  237.  
  238. enum {
  239.     uppCallComponentProcInfo = kPascalStackBased
  240.         | RESULT_SIZE(kFourByteCode)
  241.         | STACK_ROUTINE_PARAMETER(1, kFourByteCode)
  242. };
  243.  
  244. /* A few macros to simplify the code (or does it make it more complex?  ;-) */
  245. #define CallComponentGlue(ptr) \
  246.     CallUniversalProc(CallComponentUPP,uppCallComponentProcInfo,(ptr))
  247.  
  248. #define PPC_Glue(parmsType) \
  249.     unsigned char flags; \
  250.     unsigned char size; \
  251.     short what; \
  252.     parmsType parms; \
  253.     ComponentInstance inst
  254.  
  255. #define SetupGlue(var,sel,type,ic)\
  256.     (var).flags=0;\
  257.     (var).size=sizeof(type);\
  258.     (var).what=(sel);\
  259.     (var).inst=(ic)
  260.  
  261. #define PPC_VoidGlue \
  262.     unsigned char flags; \
  263.     unsigned char size; \
  264.     short what; \
  265.     ComponentInstance inst
  266.  
  267. #define SetupVoidGlue(var,sel,ic)\
  268.     (var).flags=0;\
  269.     (var).size=0;\
  270.     (var).what=(sel);\
  271.     (var).inst=(ic)
  272.  
  273. #define SetGlueParm(var,ps,val) \
  274.     (var).parms.ps=(val)
  275.  
  276. pascal ComponentResult Comp_setlogmask(ComponentInstance inst,short maskpri){
  277.     ComponentResult err;
  278.     
  279.     #pragma options align=mac68k
  280.     // Remember that these must be in reverse order from the parameters
  281.     struct GlueParms {
  282.         short maskpri;
  283.     };
  284.     
  285.     typedef struct GlueParms GlueParms;
  286.     
  287.     struct ICCallGlue {
  288.         PPC_Glue(GlueParms);
  289.     };
  290.     
  291.     typedef struct ICCallGlue ICCallGlue;
  292.     #pragma options align=reset
  293.     
  294.     ICCallGlue glue;
  295.     
  296.     if (inst == (ComponentInstance)0) {
  297.         err = badComponentInstance;
  298.     } else {
  299.         // only one for the glue struct
  300.         SetupGlue(glue,ksetlogmaskSelector,GlueParms,inst);
  301.         // the glue struct, the selector code, the parameter struct, and the instance
  302.         
  303.         // one of these for each parameter
  304.         SetGlueParm(glue,maskpri,maskpri);
  305.         // the glue struct, the parameter struct item to set, and the function parameter to use
  306.         
  307.         // call the component now
  308.         err = CallComponentGlue(&glue);
  309.     }
  310.     
  311.     return err; // return the error
  312. }
  313.  
  314. pascal ComponentResult Comp_geterror(ComponentInstance inst,OSErr* errp){
  315.     ComponentResult err;
  316.     
  317.     #pragma options align=mac68k
  318.     struct GlueParms {
  319.         OSErr* errp;
  320.     };
  321.     typedef struct GlueParms GlueParms;
  322.     struct ICCallGlue {
  323.         PPC_Glue(GlueParms);
  324.     };
  325.     typedef struct ICCallGlue ICCallGlue;
  326.     #pragma options align=reset
  327.     
  328.     ICCallGlue glue;
  329.     
  330.     if (inst == (ComponentInstance)0) {
  331.         err = badComponentInstance;
  332.     } else {
  333.         SetupGlue(glue,kGetErrorSelector,GlueParms,inst);
  334.         
  335.         SetGlueParm(glue,errp,errp);
  336.         
  337.         err = CallComponentGlue(&glue);
  338.     }
  339.     return err;
  340. }
  341.  
  342. pascal ComponentResult Comp_openlog(ComponentInstance inst,const char* ident,
  343.         long logopt,short facility){
  344.     ComponentResult err;
  345.     
  346.     #pragma options align=mac68k
  347.     struct GlueParms {
  348.         short facility;
  349.         long logopt;
  350.         const char* ident;
  351.     };
  352.     typedef struct GlueParms GlueParms;
  353.     struct ICCallGlue {
  354.         PPC_Glue(GlueParms);
  355.     };
  356.     typedef struct ICCallGlue ICCallGlue;
  357.     #pragma options align=reset
  358.     
  359.     ICCallGlue glue;
  360.     
  361.     if (inst == (ComponentInstance)0) {
  362.         err = badComponentInstance;
  363.     } else {
  364.         SetupGlue(glue,kopenlogSelector,GlueParms,inst);
  365.         
  366.         SetGlueParm(glue,ident,ident);
  367.         SetGlueParm(glue,logopt,logopt);
  368.         SetGlueParm(glue,facility,facility);
  369.         
  370.         err = CallComponentGlue(&glue);
  371.     }
  372.     return err;
  373. }
  374.  
  375. pascal ComponentResult Comp_syslog(ComponentInstance inst,short priority,
  376.         const char* message){
  377.     ComponentResult err;
  378.     
  379.     #pragma options align=mac68k
  380.     struct GlueParms {
  381.         const char* message;
  382.         short priority;
  383.     };
  384.     typedef struct GlueParms GlueParms;
  385.     struct ICCallGlue {
  386.         PPC_Glue(GlueParms);
  387.     };
  388.     typedef struct ICCallGlue ICCallGlue;
  389.     #pragma options align=reset
  390.     
  391.     ICCallGlue glue;
  392.     
  393.     if (inst == (ComponentInstance)0) {
  394.         err = badComponentInstance;
  395.     } else {
  396.         SetupGlue(glue,ksyslogSelector,GlueParms,inst);
  397.         
  398.         SetGlueParm(glue,message,message);
  399.         SetGlueParm(glue,priority,priority);
  400.         
  401.         err = CallComponentGlue(&glue);
  402.     }
  403.     return err;
  404. }
  405.  
  406. pascal ComponentResult Comp_closelog(ComponentInstance inst){
  407.     ComponentResult err;
  408.     
  409.     #pragma options align=mac68k
  410.     struct ICCallGlue {
  411.         PPC_VoidGlue;
  412.     };
  413.     typedef struct ICCallGlue ICCallGlue;
  414.     #pragma options align=reset
  415.     
  416.     ICCallGlue glue;
  417.     
  418.     if (inst == (ComponentInstance)0) {
  419.         err = badComponentInstance;
  420.     } else {
  421.         SetupVoidGlue(glue,kcloselogSelector,inst);
  422.         
  423.         err = CallComponentGlue(&glue);
  424.     }
  425.     return err;
  426. }
  427.  
  428. pascal ComponentResult Comp_setfile(ComponentInstance inst,FSSpecPtr spec){
  429.     ComponentResult err;
  430.     
  431.     #pragma options align=mac68k
  432.     struct GlueParms {
  433.         FSSpecPtr spec;
  434.     };
  435.     typedef struct GlueParms GlueParms;
  436.     struct ICCallGlue {
  437.         PPC_Glue(GlueParms);
  438.     };
  439.     typedef struct ICCallGlue ICCallGlue;
  440.     #pragma options align=reset
  441.     
  442.     ICCallGlue glue;
  443.     
  444.     if (inst == (ComponentInstance)0) {
  445.         err = badComponentInstance;
  446.     } else {
  447.         SetupGlue(glue,kSetFileSelector,GlueParms,inst);
  448.         
  449.         SetGlueParm(glue,spec,spec);
  450.         
  451.         err = CallComponentGlue(&glue);
  452.     }
  453.     return err;
  454. }
  455.  
  456. #endif
  457.  
  458.